home *** CD-ROM | disk | FTP | other *** search
/ BCI NET 2 / BCI NET 2.iso / archives / programming / source / term43-source.lha / Extras / Source / term-Source.lha / CapturePanel.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-02-18  |  20.5 KB  |  858 lines
  1. /*
  2. **    CapturePanel.c
  3. **
  4. **    Editing panel for log file, buffer and capture configuration
  5. **
  6. **    Copyright © 1990-1995 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11.  
  12. enum    {    GAD_LOGACTIONS, GAD_LOGFILE, GAD_SELECT_LOGFILE, GAD_LOGCALLS, GAD_CALL_LOGFILE,GAD_SELECT_CALL_LOGFILE,
  13.         GAD_MAX_BUFFER_SIZE,GAD_BUFFER_ENABLED,GAD_BUFFER_PATH,GAD_SELECT_BUFFER_PATH,
  14.         GAD_CONNECT_AUTO_CAPTURE, GAD_AUTOCAPTURE_DATE, GAD_CAPTURE_FILTER, GAD_CONVERT_CHARS,
  15.         GAD_CAPTURE_PATH, GAD_SELECT_CAPTURE_PATH, GAD_OPEN_BUFFER_WINDOW,
  16.         GAD_REMEMBER_WINDOW_POS,GAD_OPEN_BUFFER_SCREEN,GAD_REMEMBER_SCREEN_POS,GAD_SEARCH_HISTORY,
  17.         GAD_SCREENMODE,GAD_BUFFERSCREEN_POSITION,GAD_BUFFERWIDTH,GAD_USE, GAD_CANCEL, GAD_DEFAULT,
  18.         GAD_PAGER, GAD_PAGEGROUP,
  19.     };
  20.  
  21. STATIC BYTE  __regargs
  22. SelectDisplayMode(struct Window *Window,ULONG *CurrentMode,struct Configuration *Config)
  23. {
  24.     BYTE Success = FALSE;
  25.  
  26.     if(!Kick30)
  27.     {
  28.         struct List    *ModeList;
  29.         LONG         Index;
  30.  
  31.         if(ModeList = BuildModeList(&Index,*CurrentMode,NULL))
  32.         {
  33.             struct LayoutHandle *Handle;
  34.  
  35.             if(Handle = LT_CreateHandleTags(Window -> WScreen,
  36.                 LH_LocaleHook,    &LocaleHook,
  37.             TAG_DONE))
  38.             {
  39.                 struct Window *LocalWindow;
  40.  
  41.                 LT_New(Handle,
  42.                     LA_Type,    VERTICAL_KIND,
  43.                 TAG_DONE);
  44.                 {
  45.                     LT_New(Handle,
  46.                         LA_Type,    VERTICAL_KIND,
  47.                     TAG_DONE);
  48.                     {
  49.                         LT_New(Handle,
  50.                             LA_Type,    LISTVIEW_KIND,
  51.                             LA_LabelID,    MSG_V36_0160,
  52.                             GTLV_Labels,    ModeList,
  53.                             LA_LONG,    &Index,
  54.                             LALV_CursorKey,    TRUE,
  55.                             LALV_Link,    NIL_LINK,
  56.                             LALV_MaxGrowY,    20,
  57.                             LALV_ResizeY,    TRUE,
  58.                             LA_Lines,    10,
  59.                             LA_Chars,    40,
  60.                             LA_CursorKey,    TRUE,
  61.                         TAG_DONE);
  62.  
  63.                         LT_EndGroup(Handle);
  64.                     }
  65.  
  66.                     LT_New(Handle,
  67.                         LA_Type,VERTICAL_KIND,
  68.                     TAG_DONE);
  69.                     {
  70.                         LT_New(Handle,
  71.                             LA_Type,    XBAR_KIND,
  72.                             LAXB_FullSize,    TRUE,
  73.                         TAG_DONE);
  74.  
  75.                         LT_EndGroup(Handle);
  76.                     }
  77.  
  78.                     LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  79.                         LAGR_SameSize,    TRUE,
  80.                         LAGR_Spread,    TRUE,
  81.                     TAG_DONE);
  82.                     {
  83.                         LT_New(Handle,
  84.                             LA_Type,    BUTTON_KIND,
  85.                             LA_LabelID,    MSG_GLOBAL_USE_GAD,
  86.                             LA_ID,        GAD_USE,
  87.                             LABT_ReturnKey,    TRUE,
  88.                             LABT_ExtraFat,    TRUE,
  89.                         TAG_DONE);
  90.  
  91.                         LT_New(Handle,
  92.                             LA_Type,    BUTTON_KIND,
  93.                             LA_LabelID,    MSG_GLOBAL_CANCEL_GAD,
  94.                             LA_ID,        GAD_CANCEL,
  95.                             LABT_EscKey,    TRUE,
  96.                             LABT_ExtraFat,    TRUE,
  97.                         TAG_DONE);
  98.  
  99.                         LT_EndGroup(Handle);
  100.                     }
  101.  
  102.                     LT_EndGroup(Handle);
  103.                 }
  104.  
  105.                 if(LocalWindow = LT_Layout(Handle,LocaleString(MSG_V36_0161),NULL,0,0,IDCMP_CLOSEWINDOW,NULL,
  106.                     LAWN_HelpHook,        &GuideHook,
  107.                     LAWN_Parent,        Window,
  108.                     WA_DepthGadget,        TRUE,
  109.                     WA_CloseGadget,        TRUE,
  110.                     WA_DragBar,        TRUE,
  111.                     WA_RMBTrap,        TRUE,
  112.                     WA_Activate,        TRUE,
  113.                 TAG_DONE))
  114.                 {
  115.                     struct IntuiMessage    *Message;
  116.                     BOOL             Done = FALSE;
  117.                     ULONG             MsgClass,
  118.                                  MsgQualifier;
  119.                     UWORD             MsgCode;
  120.                     struct Gadget        *MsgGadget;
  121.                     LONG             i;
  122.                     struct ModeNode        *ModeNode;
  123.  
  124.                     do
  125.                     {
  126.                         WaitPort(LocalWindow -> UserPort);
  127.  
  128.                         while(Message = (struct IntuiMessage *)LT_GetIMsg(Handle))
  129.                         {
  130.                             MsgClass    = Message -> Class;
  131.                             MsgCode        = Message -> Code;
  132.                             MsgQualifier    = Message -> Qualifier;
  133.                             MsgGadget    = (struct Gadget *)Message -> IAddress;
  134.  
  135.                             LT_ReplyIMsg(Message);
  136.  
  137.                             if(MsgClass == IDCMP_CLOSEWINDOW)
  138.                                 Done = TRUE;
  139.  
  140.                             if(MsgClass == IDCMP_GADGETUP)
  141.                             {
  142.                                 switch(MsgGadget -> GadgetID)
  143.                                 {
  144.                                     case GAD_USE:
  145.  
  146.                                         for(ModeNode = (struct ModeNode *)ModeList -> lh_Head, i = 0 ; ModeNode -> VanillaNode . ln_Succ ; ModeNode = (struct ModeNode *)ModeNode -> VanillaNode . ln_Succ, i++)
  147.                                         {
  148.                                             if(Index == i)
  149.                                             {
  150.                                                 *CurrentMode = ModeNode -> DisplayID;
  151.  
  152.                                                 break;
  153.                                             }
  154.                                         }
  155.  
  156.                                         Success = Done = TRUE;
  157.                                         break;
  158.  
  159.                                     case GAD_CANCEL:
  160.  
  161.                                         Done = TRUE;
  162.                                         break;
  163.                                 }
  164.                             }
  165.  
  166.                             if(MsgClass == IDCMP_IDCMPUPDATE)
  167.                             {
  168.                                 for(ModeNode = (struct ModeNode *)ModeList -> lh_Head, i = 0; ModeNode -> VanillaNode . ln_Succ ; ModeNode = (struct ModeNode *)ModeNode -> VanillaNode . ln_Succ, i++)
  169.                                 {
  170.                                     if(Index == i)
  171.                                     {
  172.                                         *CurrentMode = ModeNode -> DisplayID;
  173.  
  174.                                         Success = Done = TRUE;
  175.  
  176.                                         LT_PressButton(Handle,GAD_USE);
  177.  
  178.                                         break;
  179.                                     }
  180.                                 }
  181.                             }
  182.                         }
  183.                     }
  184.                     while(!Done);
  185.                 }
  186.  
  187.                 LT_DeleteHandle(Handle);
  188.             }
  189.  
  190.             DeleteList(ModeList);
  191.         }
  192.     }
  193.     else
  194.     {
  195.         struct ScreenModeRequester    *Request;
  196.         LONG                 Left    = 0,
  197.                          Top    = 0,
  198.                          Width    = 0,
  199.                          Height    = 0;
  200.  
  201.         GetWindowInfo(WINDOW_SCREEN,&Left,&Top,&Width,&Height,Window -> Width / 2,Window -> Height / 2);
  202.  
  203.         if(Request = (struct ScreenModeRequester *)AllocAslRequestTags(ASL_ScreenModeRequest,
  204.             ASLSM_Window,            Window,
  205.             ASLSM_InitialDisplayID,        *CurrentMode,
  206.             ASLSM_PrivateIDCMP,        TRUE,
  207.  
  208.             ASL_LeftEdge,            Left,
  209.             ASL_TopEdge,            Top,
  210.             ASL_Width,            Width,
  211.             ASL_Height,            Height,
  212.         TAG_DONE))
  213.         {
  214.             if(AslRequestTags(Request,TAG_DONE))
  215.             {
  216.                 PutWindowInfo(WINDOW_SCREEN,Request -> sm_LeftEdge,Request -> sm_TopEdge,Request -> sm_Width,Request -> sm_Height);
  217.  
  218.                 *CurrentMode = Request -> sm_DisplayID;
  219.  
  220.                 Success = TRUE;
  221.             }
  222.  
  223.             FreeAslRequest(Request);
  224.         }
  225.     }
  226.  
  227.     return(Success);
  228. }
  229.  
  230. BYTE __regargs
  231. CapturePanel(struct Configuration *Config,BYTE *Default)
  232. {
  233.     STATIC LONG PageTitleID[7] =
  234.     {
  235.         MSG_V36_0008,
  236.         MSG_V36_0009,
  237.         MSG_V36_0011,
  238.         MSG_V36_0013,
  239.         MSG_V36_0014,
  240.         MSG_CAPTUREPANEL_SERVICES_TXT,
  241.         -1
  242.     };
  243.  
  244.     STATIC BYTE InitialPage = 0;
  245.  
  246.     struct LayoutHandle    *Handle;
  247.     BYTE             Cancel = FALSE;
  248.     STRPTR             PageTitle[7];
  249.  
  250.     LocalizeStringTable(PageTitle,PageTitleID);
  251.  
  252.     SaveConfig(Config,PrivateConfig);
  253.  
  254.     if(Handle = LT_CreateHandleTags(Window -> WScreen,
  255.         LH_LocaleHook,    &LocaleHook,
  256.         LH_ExitFlush,    FALSE,
  257.     TAG_DONE))
  258.     {
  259.         struct Window    *PanelWindow;
  260.         BYTE         OpenBufferWindow = Config -> CaptureConfig -> OpenBufferWindow & 0xF,
  261.                  OpenBufferScreen = Config -> CaptureConfig -> OpenBufferScreen & 0xF;
  262.         UBYTE         ModeName[DISPLAYNAMELEN + 1];
  263.         ULONG         DisplayMode;
  264.  
  265.         DisplayMode = Config -> CaptureConfig -> BufferScreenMode;
  266.  
  267.         if(ModeNotAvailable(DisplayMode))
  268.         {
  269.             if(Config && Config -> ScreenConfig)
  270.                 DisplayMode = Config -> ScreenConfig -> DisplayMode;
  271.             else
  272.                 DisplayMode = INVALID_ID;
  273.         }
  274.  
  275.         if(ModeNotAvailable(DisplayMode))
  276.         {
  277.             struct Screen *PubScreen = LockPubScreen(NULL);
  278.  
  279.             if(PubScreen)
  280.             {
  281.                 DisplayMode = GetVPModeID(&PubScreen -> ViewPort);
  282.  
  283.                 UnlockPubScreen(NULL,PubScreen);
  284.             }
  285.             else
  286.                 DisplayMode = DEFAULT_MONITOR_ID | HIRES_KEY;
  287.         }
  288.  
  289.         strcpy(ModeName,GetModeName(DisplayMode));
  290.  
  291.         LT_New(Handle,
  292.             LA_Type,    VERTICAL_KIND,
  293.         TAG_DONE);
  294.         {
  295.             LT_New(Handle,
  296.                 LA_Type,VERTICAL_KIND,
  297.             TAG_DONE);
  298.             {
  299.                 LT_New(Handle,
  300.                     LA_Type,    CYCLE_KIND,
  301.                     LA_ID,        GAD_PAGER,
  302.                     LA_LabelID,    MSG_XFER_PAGE_TXT,
  303.                     GTCY_Labels,    PageTitle,
  304.                     LACY_AutoPageID,GAD_PAGEGROUP,
  305.                     LACY_TabKey,    TRUE,
  306.                     LA_BYTE,    &InitialPage,
  307.                 TAG_DONE);
  308.  
  309.                 LT_EndGroup(Handle);
  310.             }
  311.  
  312.             LT_New(Handle,
  313.                 LA_Type,    VERTICAL_KIND,
  314.                 LA_ID,        GAD_PAGEGROUP,
  315.                 LAGR_Frame,    TRUE,
  316.                 LAGR_ActivePage,InitialPage,
  317.             TAG_DONE);
  318.             {
  319.                 LT_New(Handle,
  320.                     LA_Type,    VERTICAL_KIND,
  321.                 TAG_DONE);
  322.                 {
  323.                     LT_New(Handle,
  324.                         LA_LabelID,    MSG_CAPTUREPANEL_LOG_ACTIONS_GAD,
  325.                         LA_Type,    CHECKBOX_KIND,
  326.                         LA_ID,        GAD_LOGACTIONS,
  327.                         LA_BYTE,    &Config -> CaptureConfig -> LogActions,
  328.                     TAG_DONE);
  329.  
  330.                     LT_New(Handle,
  331.                         LA_LabelID,    MSG_CAPTUREPANEL_LOGFILE_GAD,
  332.                         LA_Type,    STRING_KIND,
  333.                         LA_ID,        GAD_LOGFILE,
  334.                         LA_Chars,    20,
  335.                         LA_STRPTR,    Config -> CaptureConfig -> LogFileName,
  336.                         LAST_Picker,    TRUE,
  337.                         GTST_MaxChars,    MAX_FILENAME_LENGTH - 1,
  338.                     TAG_DONE);
  339.  
  340.                     LT_New(Handle,
  341.                         LA_LabelID,    MSG_CAPTUREPANEL_LOG_CALLS_GAD,
  342.                         LA_Type,    CHECKBOX_KIND,
  343.                         LA_ID,        GAD_LOGCALLS,
  344.                         LA_BYTE,    &Config -> CaptureConfig -> LogCall,
  345.                     TAG_DONE);
  346.  
  347.                     LT_New(Handle,
  348.                         LA_LabelID,    MSG_CAPTUREPANEL_CALL_LOGFILE_GAD,
  349.                         LA_Type,    STRING_KIND,
  350.                         LA_ID,        GAD_CALL_LOGFILE,
  351.                         LA_STRPTR,    Config -> CaptureConfig -> CallLogFileName,
  352.                         LAST_Picker,    TRUE,
  353.                         GTST_MaxChars,    MAX_FILENAME_LENGTH - 1,
  354.                     TAG_DONE);
  355.  
  356.                     LT_EndGroup(Handle);
  357.                 }
  358.  
  359.                 LT_New(Handle,
  360.                     LA_Type,    VERTICAL_KIND,
  361.                 TAG_DONE);
  362.                 {
  363.                     LT_New(Handle,
  364.                         LA_LabelID,    MSG_CAPTUREPANEL_BUFFER_ENABLED_GAD,
  365.                         LA_Type,    CHECKBOX_KIND,
  366.                         LA_ID,        GAD_BUFFER_ENABLED,
  367.                         LA_BYTE,    &Config -> CaptureConfig -> BufferEnabled,
  368.                     TAG_DONE);
  369.  
  370.                     LT_New(Handle,
  371.                         LA_LabelID,        MSG_CAPTUREPANEL_MAX_BUFFER_SIZE_GAD,
  372.                         LA_Type,        INTEGER_KIND,
  373.                         LA_ID,            GAD_MAX_BUFFER_SIZE,
  374.                         LA_LONG,        &Config -> CaptureConfig -> MaxBufferSize,
  375.                         LAIN_UseIncrementers,    TRUE,
  376.                         LAIN_Min,        0,
  377.                     TAG_DONE);
  378.  
  379.                     LT_New(Handle,
  380.                         LA_LabelID,    MSG_CAPTUREPANEL_BUFFER_PATH_GAD,
  381.                         LA_Type,    STRING_KIND,
  382.                         LA_ID,        GAD_BUFFER_PATH,
  383.                         LA_STRPTR,    Config -> CaptureConfig -> BufferPath,
  384.                         LAST_Picker,    TRUE,
  385.                         LA_Chars,    20,
  386.                         GTST_MaxChars,    MAX_FILENAME_LENGTH - 1,
  387.                     TAG_DONE);
  388.  
  389.                     LT_New(Handle,
  390.                         LA_LabelID,        MSG_CAPTUREPANEL_BUFFER_LINE_WIDTH_GAD,
  391.                         LA_Type,        SliderType,
  392.                         LA_ID,            GAD_BUFFERWIDTH,
  393.                         LA_UBYTE,        &Config -> CaptureConfig -> BufferWidth,
  394.                         GTSL_Min,        80,
  395.                         GTSL_Max,        BUFFER_LINE_MAX,
  396.                         GTSL_LevelFormat,    "%3ld",
  397.                     TAG_DONE);
  398.  
  399.                     LT_EndGroup(Handle);
  400.                 }
  401.  
  402.                 LT_New(Handle,
  403.                     LA_Type,    VERTICAL_KIND,
  404.                 TAG_DONE);
  405.                 {
  406.                     LT_New(Handle,
  407.                         LA_Type,    VERTICAL_KIND,
  408.                     TAG_DONE);
  409.                     {
  410.                         LT_New(Handle,
  411.                             LA_LabelID,    MSG_CAPTUREPANEL_CONNECT_AUTO_CAPTURE_GAD,
  412.                             LA_Type,    CHECKBOX_KIND,
  413.                             LA_ID,        GAD_CONNECT_AUTO_CAPTURE,
  414.                             LA_BYTE,    &Config -> CaptureConfig -> ConnectAutoCapture,
  415.                         TAG_DONE);
  416.  
  417.                         LT_New(Handle,
  418.                             LA_LabelID,    MSG_CAPTUREPANEL_CAPTURE_FILTER_ENABLED_GAD,
  419.                             LA_Type,    CHECKBOX_KIND,
  420.                             LA_ID,        GAD_CAPTURE_FILTER,
  421.                             LA_BYTE,    &Config -> CaptureConfig -> CaptureFilterMode,
  422.                         TAG_DONE);
  423.  
  424.                         LT_New(Handle,
  425.                             LA_LabelID,    MSG_CONVERT_CHARACTERS_GAD,
  426.                             LA_Type,    CHECKBOX_KIND,
  427.                             LA_BYTE,    &Config -> CaptureConfig -> ConvertChars,
  428.                             GA_Disabled,    !Config -> CaptureConfig -> CaptureFilterMode,
  429.                             LA_ID,        GAD_CONVERT_CHARS,
  430.                         TAG_DONE);
  431.  
  432.                         LT_EndGroup(Handle);
  433.                     }
  434.  
  435.                     LT_New(Handle,
  436.                         LA_Type,    VERTICAL_KIND,
  437.                     TAG_DONE);
  438.                     {
  439.                         LT_New(Handle,
  440.                             LA_LabelID,    MSG_CAPTUREPANEL_CREATION_DATE_GAD,
  441.                             LA_Type,    CYCLE_KIND,
  442.                             LA_ID,        GAD_AUTOCAPTURE_DATE,
  443.                             LA_BYTE,    &Config -> CaptureConfig -> AutoCaptureDate,
  444.                             LACY_FirstLabel,MSG_CAPTUREPANEL_APPEND_DATE_TXT,
  445.                             LACY_LastLabel,    MSG_CAPTUREPANEL_WRITE_DATE_TO_FILE_TXT,
  446.                         TAG_DONE);
  447.  
  448.                         LT_New(Handle,
  449.                             LA_LabelID,    MSG_CAPTUREPANEL_CAPTURE_PATH_GAD,
  450.                             LA_Type,    STRING_KIND,
  451.                             LA_ID,        GAD_CAPTURE_PATH,
  452.                             LA_Chars,    20,
  453.                             LA_STRPTR,    Config -> CaptureConfig -> CapturePath,
  454.                             LAST_Picker,    TRUE,
  455.                             GTST_MaxChars,    MAX_FILENAME_LENGTH - 1,
  456.                         TAG_DONE);
  457.  
  458.                         LT_EndGroup(Handle);
  459.                     }
  460.  
  461.                     LT_EndGroup(Handle);
  462.                 }
  463.  
  464.                 LT_New(Handle,
  465.                     LA_Type,    VERTICAL_KIND,
  466.                 TAG_DONE);
  467.                 {
  468.                     LT_New(Handle,
  469.                         LA_LabelID,    MSG_CAPTUREPANEL_OPEN_BUFFER_WINDOW_GAD,
  470.                         LA_Type,    MX_KIND,
  471.                         LA_ID,        GAD_OPEN_BUFFER_WINDOW,
  472.                         LA_BYTE,    &OpenBufferWindow,
  473.                         LAMX_FirstLabel,MSG_CAPTUREPANEL_TOP_TXT,
  474.                         LAMX_LastLabel,    MSG_CAPTUREPANEL_END_TXT,
  475.                     TAG_DONE);
  476.  
  477.                     LT_New(Handle,
  478.                         LA_LabelID,    MSG_CAPTUREPANEL_REMEMBER_BUFFER_WINDOW_GAD,
  479.                         LA_Type,    CHECKBOX_KIND,
  480.                         LA_ID,        GAD_REMEMBER_WINDOW_POS,
  481.                         LA_BYTE,    &Config -> CaptureConfig -> RememberBufferWindow,
  482.                     TAG_DONE);
  483.  
  484.                     LT_EndGroup(Handle);
  485.                 }
  486.  
  487.                 LT_New(Handle,
  488.                     LA_Type,    VERTICAL_KIND,
  489.                 TAG_DONE);
  490.                 {
  491.                     LT_New(Handle,
  492.                         LA_Type,    VERTICAL_KIND,
  493.                     TAG_DONE);
  494.                     {
  495.                         LT_New(Handle,
  496.                             LA_LabelID,    MSG_CAPTUREPANEL_OPEN_BUFFER_SCREEN_GAD,
  497.                             LA_Type,    MX_KIND,
  498.                             LA_ID,        GAD_OPEN_BUFFER_SCREEN,
  499.                             LA_BYTE,    &OpenBufferScreen,
  500.                             LAMX_FirstLabel,MSG_CAPTUREPANEL_TOP_TXT,
  501.                             LAMX_LastLabel,    MSG_CAPTUREPANEL_END_TXT,
  502.                         TAG_DONE);
  503.  
  504.                         LT_New(Handle,
  505.                             LA_LabelID,    MSG_CAPTUREPANEL_REMEMBER_BUFFER_SCREEN_GAD,
  506.                             LA_Type,    CHECKBOX_KIND,
  507.                             LA_ID,        GAD_REMEMBER_SCREEN_POS,
  508.                             LA_BYTE,    &Config -> CaptureConfig -> RememberBufferScreen,
  509.                         TAG_DONE);
  510.  
  511.                         LT_New(Handle,
  512.                             LA_LabelID,    MSG_CAPTUREPANEL_BUFFER_SCREEN_POSITION_GAD,
  513.                             LA_Type,    MX_KIND,
  514.                             LA_ID,        GAD_BUFFERSCREEN_POSITION,
  515.                             LA_BYTE,    &Config -> CaptureConfig -> BufferScreenPosition,
  516.                             LAMX_FirstLabel,MSG_CAPTUREPANEL_LEFT_TXT,
  517.                             LAMX_LastLabel,    MSG_CAPTUREPANEL_RIGHT_TXT,
  518.                         TAG_DONE);
  519.  
  520.                         LT_EndGroup(Handle);
  521.                     }
  522.  
  523.                     LT_New(Handle,
  524.                         LA_Type,    VERTICAL_KIND,
  525.                     TAG_DONE);
  526.                     {
  527.                         LT_New(Handle,
  528.                             LA_Type,    TEXT_KIND,
  529.                             LA_LabelID,    MSG_SCREENPANEL_CURRENT_DISPLAY_MODE_GAD,
  530.                             LA_Chars,    20,
  531.                             LA_ID,        GAD_SCREENMODE,
  532.                             GTTX_Text,    ModeName,
  533.                             GTTX_Border,    TRUE,
  534.                             LATX_Picker,    TRUE,
  535.                         TAG_DONE);
  536.  
  537.                         LT_EndGroup(Handle);
  538.                     }
  539.  
  540.                     LT_EndGroup(Handle);
  541.                 }
  542.  
  543.                 LT_New(Handle,
  544.                     LA_Type,    VERTICAL_KIND,
  545.                 TAG_DONE);
  546.                 {
  547.                     if(Config -> CaptureConfig -> SearchHistory < 1)
  548.                         Config -> CaptureConfig -> SearchHistory = 10;
  549.  
  550.                     LT_New(Handle,
  551.                         LA_LabelID,        MSG_CAPTUREPANEL_SEARCH_HISTORY_GAD,
  552.                         LA_Type,        INTEGER_KIND,
  553.                         LA_ID,            GAD_SEARCH_HISTORY,
  554.                         LA_Chars,        8,
  555.                         LAIN_UseIncrementers,    TRUE,
  556.                         LAIN_Min,        1,
  557.                         LAIN_Max,        255,
  558.                         LA_BYTE,        &Config -> CaptureConfig -> SearchHistory,
  559.                     TAG_DONE);
  560.  
  561.                     LT_EndGroup(Handle);
  562.                 }
  563.  
  564.                 LT_EndGroup(Handle);
  565.             }
  566.  
  567.             LT_New(Handle,
  568.                 LA_Type,    VERTICAL_KIND,
  569.             TAG_DONE);
  570.             {
  571.                 LT_New(Handle,LA_Type,XBAR_KIND,LAXB_FullSize,TRUE,TAG_DONE);
  572.  
  573.                 LT_EndGroup(Handle);
  574.             }
  575.  
  576.             LT_New(Handle,LA_Type,HORIZONTAL_KIND,
  577.                 LAGR_SameSize,    TRUE,
  578.                 LAGR_Spread,    TRUE,
  579.             TAG_DONE);
  580.             {
  581.                 LT_New(Handle,
  582.                     LA_Type,    BUTTON_KIND,
  583.                     LA_LabelID,    MSG_GLOBAL_USE_GAD,
  584.                     LA_ID,        GAD_USE,
  585.                     LABT_ReturnKey,    TRUE,
  586.                     LABT_ExtraFat,    TRUE,
  587.                 TAG_DONE);
  588.  
  589.                 if(Default)
  590.                 {
  591.                     LT_New(Handle,
  592.                         LA_Type,    BUTTON_KIND,
  593.                         LA_LabelID,    MSG_GLOBAL_DEFAULT_GAD,
  594.                         LA_ID,        GAD_DEFAULT,
  595.                         LABT_ExtraFat,    TRUE,
  596.                     TAG_DONE);
  597.                 }
  598.  
  599.                 LT_New(Handle,
  600.                     LA_Type,    BUTTON_KIND,
  601.                     LA_LabelID,    MSG_GLOBAL_CANCEL_GAD,
  602.                     LA_ID,        GAD_CANCEL,
  603.                     LABT_EscKey,    TRUE,
  604.                     LABT_ExtraFat,    TRUE,
  605.                 TAG_DONE);
  606.  
  607.                 LT_EndGroup(Handle);
  608.             }
  609.  
  610.             LT_EndGroup(Handle);
  611.         }
  612.  
  613.         if(PanelWindow = LT_Layout(Handle,LocaleString(MSG_CAPTUREPANEL_CAPTURE_SETTINGS_TXT),NULL,0,0,IDCMP_CLOSEWINDOW,0,
  614.             LAWN_HelpHook,        &GuideHook,
  615.             LAWN_Parent,        Window,
  616.             WA_DepthGadget,        TRUE,
  617.             WA_CloseGadget,        TRUE,
  618.             WA_DragBar,        TRUE,
  619.             WA_RMBTrap,        TRUE,
  620.             WA_Activate,        TRUE,
  621.         TAG_DONE))
  622.         {
  623.             struct IntuiMessage    *Message;
  624.             BOOLEAN             Done = FALSE;
  625.             ULONG             MsgClass,
  626.                          MsgQualifier;
  627.             UWORD             MsgCode;
  628.             struct Gadget        *MsgGadget;
  629.             UBYTE             DummyBuffer[MAX_FILENAME_LENGTH],
  630.                         *DummyChar;
  631.             struct FileRequester    *FileRequest;
  632.  
  633.             GuideContext(CONTEXT_CAPTURE);
  634.  
  635.             PushWindow(PanelWindow);
  636.  
  637.             LT_ShowWindow(Handle,TRUE);
  638.  
  639.             do
  640.             {
  641.                 if(Wait(PORTMASK(PanelWindow -> UserPort) | SIG_BREAK) & SIG_BREAK)
  642.                 {
  643.                     SaveConfig(PrivateConfig,Config);
  644.  
  645.                     break;
  646.                 }
  647.  
  648.                 while(Message = (struct IntuiMessage *)GT_GetIMsg(PanelWindow -> UserPort))
  649.                 {
  650.                     MsgClass    = Message -> Class;
  651.                     MsgQualifier    = Message -> Qualifier;
  652.                     MsgCode        = Message -> Code;
  653.                     MsgGadget    = (struct Gadget *)Message -> IAddress;
  654.  
  655.                     GT_ReplyIMsg(Message);
  656.  
  657.                     LT_HandleInput(Handle,MsgQualifier,&MsgClass,&MsgCode,&MsgGadget);
  658.  
  659.                     if(MsgClass == IDCMP_CLOSEWINDOW)
  660.                     {
  661.                         SaveConfig(PrivateConfig,Config);
  662.  
  663.                         Done = TRUE;
  664.                     }
  665.  
  666.                     if(MsgClass == IDCMP_GADGETUP)
  667.                     {
  668.                         switch(MsgGadget -> GadgetID)
  669.                         {
  670.                             case GAD_CAPTURE_FILTER:
  671.  
  672.                                 LT_SetAttributes(Handle,GAD_CONVERT_CHARS,
  673.                                     GA_Disabled,    !Config -> CaptureConfig -> CaptureFilterMode,
  674.                                 TAG_DONE);
  675.  
  676.                                 break;
  677.  
  678.                             case GAD_USE:
  679.  
  680.                                 LT_UpdateStrings(Handle);
  681.  
  682.                                 Config -> CaptureConfig -> OpenBufferWindow = OpenBufferWindow;
  683.                                 Config -> CaptureConfig -> OpenBufferScreen = OpenBufferScreen;
  684.                                 Config -> CaptureConfig -> BufferScreenMode = DisplayMode;
  685.  
  686.                                 Done = TRUE;
  687.                                 break;
  688.  
  689.                             case GAD_CANCEL:
  690.  
  691.                                 SaveConfig(PrivateConfig,Config);
  692.  
  693.                                 Cancel = Done = TRUE;
  694.                                 break;
  695.  
  696.                             case GAD_DEFAULT:
  697.  
  698.                                 *Default = TRUE;
  699.  
  700.                                 Done = TRUE;
  701.                                 break;
  702.  
  703.                             case GAD_LOGFILE:
  704.                             case GAD_CALL_LOGFILE:
  705.  
  706.                                 FindPath(PanelWindow,LT_GetString(Handle,MsgGadget -> GadgetID),TRUE,NULL);
  707.                                 break;
  708.  
  709.                             case GAD_BUFFER_PATH:
  710.                             case GAD_CAPTURE_PATH:
  711.  
  712.                                 FindDrawer(PanelWindow,LT_GetString(Handle,MsgGadget -> GadgetID),TRUE,NULL);
  713.                                 break;
  714.                         }
  715.                     }
  716.  
  717.                     if(MsgClass == IDCMP_IDCMPUPDATE)
  718.                     {
  719.                         switch(MsgGadget -> GadgetID)
  720.                         {
  721.                             case GAD_LOGFILE:
  722.  
  723.                                 LT_LockWindow(PanelWindow);
  724.  
  725.                                 strcpy(DummyBuffer,(STRPTR)LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE));
  726.  
  727.                                 if(DummyBuffer[0])
  728.                                 {
  729.                                     if(FilePart(DummyBuffer) == DummyBuffer)
  730.                                         DummyBuffer[0] = 0;
  731.                                     else
  732.                                     {
  733.                                         DummyChar = PathPart(DummyBuffer);
  734.  
  735.                                         *DummyChar = 0;
  736.                                     }
  737.  
  738.                                     DummyChar = FilePart((STRPTR)LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE));
  739.                                 }
  740.                                 else
  741.                                     DummyChar = "";
  742.  
  743.                                 if(FileRequest = GetFile(PanelWindow,LocaleString(MSG_CAPTUREPANEL_SELECT_LOGFILE_TXT),DummyBuffer,DummyChar,DummyBuffer,NULL,FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  744.                                 {
  745.                                     FindPath(PanelWindow,DummyBuffer,TRUE,NULL);
  746.  
  747.                                     LT_SetAttributes(Handle,MsgGadget -> GadgetID,GTST_String,DummyBuffer,TAG_DONE);
  748.  
  749.                                     FreeAslRequest(FileRequest);
  750.                                 }
  751.  
  752.                                 LT_UnlockWindow(PanelWindow);
  753.                                 break;
  754.  
  755.                             case GAD_CALL_LOGFILE:
  756.  
  757.                                 LT_LockWindow(PanelWindow);
  758.  
  759.                                 strcpy(DummyBuffer,(STRPTR)LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE));
  760.  
  761.                                 if(DummyBuffer[0])
  762.                                 {
  763.                                     if(FilePart(DummyBuffer) == DummyBuffer)
  764.                                         DummyBuffer[0] = 0;
  765.                                     else
  766.                                     {
  767.                                         DummyChar = PathPart(DummyBuffer);
  768.  
  769.                                         *DummyChar = 0;
  770.                                     }
  771.  
  772.                                     DummyChar = FilePart((STRPTR)LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE));
  773.                                 }
  774.                                 else
  775.                                     DummyChar = "";
  776.  
  777.                                 if(FileRequest = GetFile(PanelWindow,LocaleString(MSG_CAPTUREPANEL_SELECT_CALL_LOGFILE_TXT),DummyBuffer,DummyChar,DummyBuffer,NULL,FALSE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  778.                                 {
  779.                                     FindPath(PanelWindow,DummyBuffer,TRUE,NULL);
  780.  
  781.                                     LT_SetAttributes(Handle,MsgGadget -> GadgetID,GTST_String,DummyBuffer,TAG_DONE);
  782.  
  783.                                     FreeAslRequest(FileRequest);
  784.                                 }
  785.  
  786.                                 LT_UnlockWindow(PanelWindow);
  787.                                 break;
  788.  
  789.                             case GAD_BUFFER_PATH:
  790.  
  791.                                 LT_LockWindow(PanelWindow);
  792.  
  793.                                 strcpy(DummyBuffer,(STRPTR)LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE));
  794.  
  795.                                 if(FileRequest = GetFile(PanelWindow,LocaleString(MSG_CAPTUREPANEL_SELECT_BUFFER_PATH_TXT),DummyBuffer,"",DummyBuffer,NULL,FALSE,FALSE,TRUE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  796.                                 {
  797.                                     FindDrawer(PanelWindow,DummyBuffer,TRUE,NULL);
  798.  
  799.                                     LT_SetAttributes(Handle,MsgGadget -> GadgetID,GTST_String,DummyBuffer,TAG_DONE);
  800.  
  801.                                     FreeAslRequest(FileRequest);
  802.                                 }
  803.  
  804.                                 LT_UnlockWindow(PanelWindow);
  805.                                 break;
  806.  
  807.                             case GAD_CAPTURE_PATH:
  808.  
  809.                                 LT_LockWindow(PanelWindow);
  810.  
  811.                                 strcpy(DummyBuffer,(STRPTR)LT_GetAttributes(Handle,MsgGadget -> GadgetID,TAG_DONE));
  812.  
  813.                                 if(FileRequest = GetFile(PanelWindow,LocaleString(MSG_CAPTUREPANEL_SELECT_CAPTURE_PATH_TXT),DummyBuffer,"",DummyBuffer,NULL,FALSE,FALSE,TRUE,LocaleString(MSG_GLOBAL_SELECT_TXT),TRUE))
  814.                                 {
  815.                                     FindDrawer(PanelWindow,DummyBuffer,TRUE,NULL);
  816.  
  817.                                     LT_SetAttributes(Handle,MsgGadget -> GadgetID,GTST_String,DummyBuffer,TAG_DONE);
  818.  
  819.                                     FreeAslRequest(FileRequest);
  820.                                 }
  821.  
  822.                                 LT_UnlockWindow(PanelWindow);
  823.                                 break;
  824.  
  825.                             case GAD_SCREENMODE:
  826.  
  827.                                 LT_LockWindow(PanelWindow);
  828.  
  829.                                 if(SelectDisplayMode(PanelWindow,&DisplayMode,Config))
  830.                                 {
  831.                                     strcpy(ModeName,GetModeName(DisplayMode));
  832.  
  833.                                     LT_SetAttributes(Handle,GAD_SCREENMODE,GTTX_Text,ModeName,TAG_DONE);
  834.                                 }
  835.  
  836.                                 LT_UnlockWindow(PanelWindow);
  837.  
  838.                                 LT_ShowWindow(Handle,TRUE);
  839.  
  840.                                 break;
  841.                         }
  842.                     }
  843.                 }
  844.             }
  845.             while(!Done);
  846.  
  847.             PopWindow();
  848.         }
  849.  
  850.         LT_DeleteHandle(Handle);
  851.     }
  852.  
  853.     if(Default)
  854.         return((BYTE)(!Cancel));
  855.     else
  856.         return((BYTE)memcmp(PrivateConfig -> CaptureConfig,Config -> CaptureConfig,sizeof(struct CaptureSettings)));
  857. }
  858.